package com.kds.fxtool.controller;

import com.kds.fxtool.config.SceneManager;
import com.kds.fxtool.domain.MenuItem;
import com.kds.fxtool.service.MenuService;
import javafx.application.Platform;
import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.fxml.Initializable;
import javafx.scene.control.*;
import javafx.scene.layout.*;
import javafx.scene.Node;
import javafx.scene.shape.Circle;
import javafx.scene.layout.StackPane;
import javafx.geometry.Pos;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.util.Duration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.net.URL;
import java.lang.reflect.Method;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.ResourceBundle;

public class MainController implements Initializable {
    private static final Logger logger = LoggerFactory.getLogger(MainController.class);

    @FXML private StackPane contentArea;
    @FXML private Label currentPageLabel;
    @FXML private TextField globalSearchField;
    @FXML private Label systemStatusLabel;
    @FXML private Label connectionStatusLabel;
    @FXML private Label currentUserLabel;
    @FXML private Label lastLoginLabel;
    @FXML private Label currentTimeLabel;

    private MenuService menuService = new MenuService();
    private boolean sidebarCollapsed = false;
    private boolean isMaximized = false;
    private String currentPage = "home";
    private Timeline timeUpdateTimeline;
    private SplitPane mainSplitPane;

    @Override
    public void initialize(URL location, ResourceBundle resources) {
        setupMenuInteractions();
        setupStatusBar();
        setupGlobalSearch();
        startTimeUpdate();

        // 延迟执行导航和菜单构建
        Platform.runLater(() -> {
            if (contentArea != null) {
                // 构建动态菜单
                buildDynamicMenu();
                // 导航到首页
                navigateToHome();
                // 设置窗口大小变化监听器
                setupWindowSizeListener();
            } else {
                logger.error("contentArea 注入失败，无法初始化界面");
                showError("界面初始化失败，请重启应用");
            }
        });
    }

    // ==================== 动态菜单构建方法 ====================

    /**
     * 动态构建导航菜单（树形结构）
     */
    private void buildDynamicMenu() {
        try {
            List<MenuItem> menuTree = menuService.loadMenuTree();
            Accordion accordion = createMenuAccordionFromTree(menuTree);

            // 查找侧边栏容器
            VBox sidebar = (VBox) contentArea.getScene().lookup(".sidebar");
            if (sidebar != null) {
                // 查找菜单容器区域
                ScrollPane scrollPane = (ScrollPane) sidebar.lookup(".sidebar-scroll");
                if (scrollPane != null) {
                    VBox menuContainer = (VBox) scrollPane.getContent();
                    if (menuContainer != null) {
                        // 清除现有内容
                        menuContainer.getChildren().clear();
                        
                        // 添加动态菜单
                        accordion.getStyleClass().add("sidebar-accordion");
                        menuContainer.getChildren().add(accordion);
                        
                        logger.info("动态菜单构建完成，共加载 {} 个菜单组", menuTree.size());
                    } else {
                        logger.error("找不到菜单容器");
                    }
                } else {
                    logger.error("找不到滚动面板");
                }
            } else {
                logger.error("找不到侧边栏容器");
            }

        } catch (Exception e) {
            logger.error("构建动态菜单失败", e);
            showError("菜单加载失败，使用默认菜单");
        }
    }

    /**
     * 从树形结构创建菜单 Accordion
     */
    private Accordion createMenuAccordionFromTree(List<MenuItem> menuTree) {
        Accordion accordion = new Accordion();

        for (MenuItem groupItem : menuTree) {
            if (groupItem.isGroup()) {
                TitledPane groupPane = createMenuGroupPane(groupItem);
                accordion.getPanes().add(groupPane);
            }
        }

        // 设置默认展开的面板
        if (!accordion.getPanes().isEmpty()) {
            // 展开第一个面板，或者根据配置展开特定面板
            for (TitledPane pane : accordion.getPanes()) {
                MenuItem menuData = (MenuItem) pane.getUserData();
                if (menuData != null && menuData.isExpanded()) {
                    accordion.setExpandedPane(pane);
                    break;
                }
            }

            // 如果没有设置展开的面板，默认展开第一个
            if (accordion.getExpandedPane() == null && !accordion.getPanes().isEmpty()) {
                accordion.setExpandedPane(accordion.getPanes().get(0));
            }
        }

        return accordion;
    }

    /**
     * 创建菜单分组面板
     */
    private TitledPane createMenuGroupPane(MenuItem groupItem) {
        TitledPane pane = new TitledPane();
        pane.setText(groupItem.getTitle());
        pane.getStyleClass().add("accordion-pane");
        pane.setExpanded(groupItem.isExpanded());

        // 存储菜单数据，便于后续使用
        pane.setUserData(groupItem);

        // 创建分组内容
        VBox contentBox = new VBox();
        contentBox.getStyleClass().add("accordion-content");
        contentBox.setSpacing(5);

        // 递归添加子菜单项
        addMenuItemsToGroup(contentBox, groupItem.getChildren());

        pane.setContent(contentBox);
        return pane;
    }

    /**
     * 递归添加菜单项到分组
     */
    private void addMenuItemsToGroup(VBox parentBox, List<MenuItem> menuItems) {
        for (MenuItem menuItem : menuItems) {
            if (menuItem.isLeaf()) {
                // 叶子节点：创建按钮
                Button menuButton = createMenuButton(menuItem);
                parentBox.getChildren().add(menuButton);
            } else {
                // 非叶子节点：创建子分组（支持多级菜单）
                VBox subGroupBox = createSubMenuGroup(menuItem);
                parentBox.getChildren().add(subGroupBox);
            }
        }
    }

    /**
     * 创建子菜单分组（支持多级菜单）
     */
    private VBox createSubMenuGroup(MenuItem subGroupItem) {
        VBox subGroupBox = new VBox();
        subGroupBox.getStyleClass().add("sub-menu-group");
        subGroupBox.setSpacing(3);

        // 子分组标题
        Label subGroupLabel = new Label(subGroupItem.getTitle());
        subGroupLabel.getStyleClass().add("sub-menu-title");
        subGroupBox.getChildren().add(subGroupLabel);

        // 递归添加子项
        addMenuItemsToGroup(subGroupBox, subGroupItem.getChildren());

        return subGroupBox;
    }

    /**
     * 创建菜单按钮
     */
    private Button createMenuButton(MenuItem menuItem) {
        Button button = new Button();
        button.getStyleClass().add("accordion-button");

        // 创建按钮内容布局
        HBox buttonContent = new HBox();
        buttonContent.setSpacing(8);
        buttonContent.setAlignment(Pos.CENTER_LEFT);

        // 添加图标（如果有）
        if (menuItem.getIcon() != null && !menuItem.getIcon().isEmpty()) {
            Label iconLabel = new Label(menuItem.getIcon());
            iconLabel.getStyleClass().add("menu-icon");
            buttonContent.getChildren().add(iconLabel);
        }

        // 添加文本
        Label textLabel = new Label(menuItem.getTitle());
        // 移除可能导致类型转换错误的内联样式
        textLabel.getStyleClass().add("menu-text");
        buttonContent.getChildren().add(textLabel);

        // 设置按钮内容
        button.setGraphic(buttonContent);

        // 设置工具提示
        button.setTooltip(new Tooltip(menuItem.getTitle()));

        // 设置点击事件
        button.setOnAction(event -> {
            handleMenuAction(menuItem);
        });

        return button;
    }

    /**
     * 处理菜单动作
     */
    private void handleMenuAction(MenuItem menuItem) {
        try {
            logger.info("执行菜单动作: {}", menuItem.getTitle());

            String action = menuItem.getAction();
            if (action != null && !action.isEmpty()) {
                // 使用反射调用对应的方法
                Method method = this.getClass().getDeclaredMethod(action);
                method.invoke(this);
            } else if (menuItem.getFxmlFile() != null && !menuItem.getFxmlFile().isEmpty()) {
                // 直接加载FXML文件
                loadPage(menuItem.getFxmlFile(), getCategoryFromTree(menuItem),
                        menuItem.getTitle(), menuItem.getId());
            } else {
                logger.warn("菜单项未配置动作或FXML文件: {}", menuItem.getTitle());
                showAlert("提示", "该功能正在开发中");
            }

            // 更新面包屑
            updateBreadcrumbForMenu(menuItem);

        } catch (NoSuchMethodException e) {
            logger.error("未找到菜单动作方法: {}", menuItem.getAction(), e);
            showError("菜单功能暂不可用: " + menuItem.getTitle());
        } catch (Exception e) {
            logger.error("执行菜单动作失败: {}", menuItem.getTitle(), e);
            showError("执行操作失败: " + e.getMessage());
        }
    }

    /**
     * 从菜单树中获取分类名称
     */
    private String getCategoryFromTree(MenuItem menuItem) {
        // 这里可以根据需要实现更复杂的逻辑来获取完整的面包屑路径
        // 简单实现：返回菜单项的标题
        return menuItem.getTitle();
    }

    /**
     * 更新面包屑导航（支持多级菜单）
     */
    private void updateBreadcrumbForMenu(MenuItem menuItem) {
        if (currentPageLabel != null) {
            currentPageLabel.setText(menuItem.getTitle());
        }

        // 在实际项目中，可以在这里实现完整的面包屑路径更新
        // 例如：首页 > 用户管理 > 用户列表
    }

    /**
     * 添加快捷操作（现在快速操作已经在FXML中静态定义）
     */
    private void addQuickActions(VBox sidebar) {
        // 快速操作现在已经在FXML中静态定义，这里可以添加动态的快速操作
        // 或者根据用户权限动态显示/隐藏某些快速操作
        try {
            List<MenuItem> quickActions = menuService.getQuickActionsTree();
            
            // 查找快速操作容器
            VBox quickActionsContainer = (VBox) sidebar.lookup(".sidebar-quick-actions");
            if (quickActionsContainer != null) {
                // 可以根据接口返回的数据动态添加额外的快速操作
                // 或者根据用户权限过滤显示的快速操作
                
                // 示例：动态添加基于接口数据的快速操作
                for (MenuItem action : quickActions) {
                    if (!action.getTitle().contains("刷新") && 
                        !action.getTitle().contains("导出") && 
                        !action.getTitle().contains("帮助")) {
                        
                        Button button = new Button(action.getTitle());
                        button.getStyleClass().add("sidebar-quick-btn");
                        button.setOnAction(event -> handleQuickAction(action));
                        quickActionsContainer.getChildren().add(button);
                    }
                }
            }
        } catch (Exception e) {
            logger.error("添加动态快速操作失败", e);
        }
    }

    /**
     * 处理快捷操作
     */
    private void handleQuickAction(MenuItem action) {
        switch (action.getId()) {
            case "refresh":
                refreshCache();
                break;
            case "export":
                exportData();
                break;
            case "help":
                showHelp();
                break;
            default:
                logger.warn("未知的快捷操作: {}", action.getId());
                break;
        }
    }

    /**
     * 根据用户权限刷新菜单
     */
    public void refreshMenuWithPermissions(List<String> userPermissions) {
        try {
            List<MenuItem> fullMenuTree = menuService.loadMenuTree();
            List<MenuItem> filteredMenuTree = menuService.filterMenuByPermission(fullMenuTree, userPermissions);

            // 重新构建菜单
            Accordion accordion = createMenuAccordionFromTree(filteredMenuTree);

            // 查找侧边栏容器
            VBox sidebar = (VBox) contentArea.getScene().lookup(".sidebar");
            if (sidebar != null) {
                // 查找菜单容器区域
                ScrollPane scrollPane = (ScrollPane) sidebar.lookup(".sidebar-scroll");
                if (scrollPane != null) {
                    VBox menuContainer = (VBox) scrollPane.getContent();
                    if (menuContainer != null) {
                        // 清除现有内容
                        menuContainer.getChildren().clear();
                        
                        // 添加过滤后的菜单
                        accordion.getStyleClass().add("sidebar-accordion");
                        menuContainer.getChildren().add(accordion);
                        
                        logger.info("菜单权限过滤完成，显示 {} 个菜单组", filteredMenuTree.size());
                    }
                }
            }

        } catch (Exception e) {
            logger.error("根据权限刷新菜单失败", e);
            showError("菜单权限更新失败");
        }
    }

    // ==================== 页面导航方法 ====================

    /**
     * 显示首页
     */
    @FXML
    private void navigateToHome() {
        if (contentArea == null) {
            logger.error("contentArea 为 null，无法导航到首页");
            return;
        }
        loadPage("home-page.fxml", "首页", "控制台", "home");
    }

    @FXML
    private void navigateToWorkspace() {
        showPlaceholderPage("工作台", "workspace");
        updateBreadcrumb("首页", "工作台");
        setActiveMenu("workspace");
    }

    /**
     * 用户管理相关页面
     */
    @FXML
    private void navigateToUserList() {
        loadPage("user-list.fxml", "用户管理", "用户列表", "userList");
    }

    @FXML
    private void navigateToAddUser() {
        loadPage("add-user.fxml", "用户管理", "新增用户", "addUser");
    }

    @FXML
    private void navigateToUserRoles() {
        showPlaceholderPage("用户角色配置", "userRoles");
        updateBreadcrumb("用户管理", "角色配置");
        setActiveMenu("userRoles");
    }

    /**
     * 订单管理相关页面
     */
    @FXML
    private void navigateToOrderList() {
        showPlaceholderPage("订单列表", "orderList");
        updateBreadcrumb("订单管理", "订单列表");
        setActiveMenu("orderList");
    }

    @FXML
    private void navigateToOrderAnalysis() {
        showPlaceholderPage("订单分析", "orderAnalysis");
        updateBreadcrumb("订单管理", "订单分析");
        setActiveMenu("orderAnalysis");
    }

    /**
     * 数据统计相关页面
     */
    @FXML
    private void navigateToStatistics() {
        showPlaceholderPage("数据统计", "statistics");
        updateBreadcrumb("数据统计", "数据概览");
        setActiveMenu("statistics");
    }

    @FXML
    private void navigateToReports() {
        showPlaceholderPage("报表分析", "reports");
        updateBreadcrumb("数据统计", "报表分析");
        setActiveMenu("reports");
    }

    /**
     * 系统设置相关页面
     */
    @FXML
    private void navigateToSystemConfig() {
        showPlaceholderPage("系统配置", "systemConfig");
        updateBreadcrumb("系统设置", "系统配置");
        setActiveMenu("systemConfig");
    }

    @FXML
    private void navigateToLogManagement() {
        showPlaceholderPage("日志管理", "logManagement");
        updateBreadcrumb("系统设置", "日志管理");
        setActiveMenu("logManagement");
    }

    /**
     * 个人中心相关页面
     */
    @FXML
    private void navigateToProfile() {
        showPlaceholderPage("个人中心", "profile");
        updateBreadcrumb("个人中心", "个人信息");
        setActiveMenu("profile");
    }

    @FXML
    private void navigateToSettings() {
        showPlaceholderPage("账户设置", "settings");
        updateBreadcrumb("个人中心", "账户设置");
        setActiveMenu("settings");
    }

    // ==================== 通用页面加载方法 ====================

    /**
     * 通用页面加载方法
     */
    private void loadPage(String fxmlFile, String category, String current, String pageId) {
        try {
            if (contentArea == null) {
                logger.error("contentArea 未初始化，无法加载页面: " + fxmlFile);
                showError("界面初始化失败，无法加载页面");
                return;
            }

            contentArea.getChildren().clear();

            URL resourceUrl = getClass().getResource("/fxml/" + fxmlFile);
            if (resourceUrl == null) {
                logger.error("找不到FXML文件: " + fxmlFile);
                showPlaceholderPage(current, pageId);
                return;
            }

            FXMLLoader loader = new FXMLLoader(resourceUrl);
            Node pageContent = loader.load();

            contentArea.getChildren().add(pageContent);
            currentPage = pageId;
            updateBreadcrumb(category, current);
            setActiveMenu(pageId);

            // 设置页面特定的事件处理
            setupPageEvents(pageContent, pageId);

        } catch (Exception e) {
            logger.error("加载页面失败: {}", fxmlFile, e);
            showError("加载页面失败: " + e.getMessage());
            showPlaceholderPage(current, pageId);
        }
    }

    /**
     * 显示占位页面（用于未实现的页面）
     */
    private void showPlaceholderPage(String pageTitle, String pageId) {
        try {
            if (contentArea == null) {
                logger.error("contentArea 未初始化，无法显示占位页面: " + pageTitle);
                return;
            }

            contentArea.getChildren().clear();

            VBox placeholder = new VBox();
            placeholder.getStyleClass().add("placeholder-page");
            placeholder.setSpacing(20);
            placeholder.setAlignment(Pos.CENTER);

            Label titleLabel = new Label(pageTitle);
            titleLabel.getStyleClass().add("placeholder-title");

            Label descLabel = new Label("此功能正在开发中，敬请期待...");
            descLabel.getStyleClass().add("placeholder-desc");

            Button backButton = new Button("返回首页");
            backButton.getStyleClass().add("primary-btn");
            backButton.setOnAction(e -> navigateToHome());

            placeholder.getChildren().addAll(titleLabel, descLabel, backButton);
            contentArea.getChildren().add(placeholder);

            currentPage = pageId;
            updateBreadcrumb("首页", pageTitle);
        } catch (Exception e) {
            logger.error("加载占位页面失败", e);
            showError("加载占位页面失败");
        }
    }

    /**
     * 设置页面特定事件
     */
    private void setupPageEvents(Node pageContent, String pageId) {
        switch (pageId) {
            case "home":
                setupHomePageEvents(pageContent);
                break;
            case "userList":
                setupUserListEvents(pageContent);
                break;
            case "addUser":
                setupAddUserEvents(pageContent);
                break;
            default:
                // 其他页面的通用事件设置
                setupCommonPageEvents(pageContent);
                break;
        }
    }

    /**
     * 设置首页事件
     */
    private void setupHomePageEvents(Node homeContent) {
        try {
            // 设置快捷操作按钮事件
            setupQuickActionButtons(homeContent);

            // 设置页面操作按钮事件
            setupPageActionButtons(homeContent);

            // 设置查看全部链接事件
            setupViewAllLinks(homeContent);

        } catch (Exception e) {
            logger.error("设置首页事件失败", e);
        }
    }

    /**
     * 设置快捷操作按钮事件
     */
    private void setupQuickActionButtons(Node homeContent) {
        try {
            // 通过CSS类名查找按钮
            Node quickActionsFlow = homeContent.lookup(".quick-actions-flow");
            if (quickActionsFlow instanceof javafx.scene.layout.FlowPane) {
                FlowPane flowPane = (FlowPane) quickActionsFlow;
                for (Node node : flowPane.getChildren()) {
                    if (node instanceof Button) {
                        Button button = (Button) node;
                        String buttonText = button.getText();
                        if (buttonText != null) {
                            switch (buttonText) {
                                case "新增用户":
                                    button.setOnAction(e -> navigateToAddUser());
                                    break;
                                case "订单管理":
                                    button.setOnAction(e -> navigateToOrderList());
                                    break;
                                case "数据统计":
                                    button.setOnAction(e -> navigateToStatistics());
                                    break;
                                case "系统设置":
                                    button.setOnAction(e -> navigateToSystemConfig());
                                    break;
                                case "报表导出":
                                    button.setOnAction(e -> exportReport());
                                    break;
                                case "数据备份":
                                    button.setOnAction(e -> backupData());
                                    break;
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error("设置快捷操作按钮事件失败", e);
        }
    }

    /**
     * 设置页面操作按钮事件
     */
    private void setupPageActionButtons(Node homeContent) {
        try {
            // 查找页面操作区域的按钮
            HBox pageActions = (HBox) homeContent.lookup(".page-actions");
            if (pageActions != null) {
                for (Node node : pageActions.getChildren()) {
                    if (node instanceof Button) {
                        Button button = (Button) node;
                        String buttonText = button.getText();
                        if (buttonText != null) {
                            switch (buttonText) {
                                case "🔄 刷新":
                                    button.setOnAction(e -> refreshData());
                                    break;
                                case "📊 生成报告":
                                    button.setOnAction(e -> generateReport());
                                    break;
                                case "➕ 快速操作":
                                    button.setOnAction(e -> quickAction());
                                    break;
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error("设置页面操作按钮事件失败", e);
        }
    }

    /**
     * 设置查看全部链接事件
     */
    private void setupViewAllLinks(Node homeContent) {
        try {
            Hyperlink viewAllLink = (Hyperlink) homeContent.lookup(".view-all-link");
            if (viewAllLink != null) {
                viewAllLink.setOnAction(e -> viewAllActivities());
            }
        } catch (Exception e) {
            logger.error("设置查看全部链接事件失败", e);
        }
    }

    /**
     * 设置用户列表页面事件
     */
    private void setupUserListEvents(Node userListContent) {
        try {
            // 用户列表页面的特定事件设置
            Button addUserBtn = (Button) userListContent.lookup(".primary-btn");
            if (addUserBtn != null && "➕ 新增用户".equals(addUserBtn.getText())) {
                addUserBtn.setOnAction(e -> navigateToAddUser());
            }

            Button refreshBtn = (Button) userListContent.lookup(".secondary-btn");
            if (refreshBtn != null && "🔄 刷新".equals(refreshBtn.getText())) {
                refreshBtn.setOnAction(e -> refreshData());
            }

        } catch (Exception e) {
            logger.error("设置用户列表页面事件失败", e);
        }
    }

    /**
     * 设置新增用户页面事件
     */
    private void setupAddUserEvents(Node addUserContent) {
        try {
            // 新增用户页面的特定事件设置
            Button backBtn = (Button) addUserContent.lookup(".secondary-btn");
            if (backBtn != null && "⬅️ 返回".equals(backBtn.getText())) {
                backBtn.setOnAction(e -> navigateToUserList());
            }

            Button saveBtn = (Button) addUserContent.lookup(".primary-btn");
            if (saveBtn != null && "💾 保存".equals(saveBtn.getText())) {
                saveBtn.setOnAction(e -> saveUser());
            }

        } catch (Exception e) {
            logger.error("设置新增用户页面事件失败", e);
        }
    }

    /**
     * 设置通用页面事件
     */
    private void setupCommonPageEvents(Node pageContent) {
        try {
            // 为所有页面的刷新按钮设置事件
            Button refreshBtn = (Button) pageContent.lookup(".secondary-btn");
            if (refreshBtn != null && "🔄 刷新".equals(refreshBtn.getText())) {
                refreshBtn.setOnAction(e -> refreshData());
            }
        } catch (Exception e) {
            logger.error("设置通用页面事件失败", e);
        }
    }

    // ==================== 菜单交互方法 ====================

    /**
     * 切换侧边栏显示/隐藏
     */
    @FXML
    private void toggleSidebar() {
        // 由于侧边栏现在是独立组件，这里可以添加一些视觉反馈
        showAlert("操作", "切换侧边栏");
    }

    /**
     * 设置菜单交互
     */
    private void setupMenuInteractions() {
        // 可以在这里添加菜单的初始状态设置
        // 例如默认展开某些菜单项等
    }

    /**
     * 设置激活的菜单项
     */
    private void setActiveMenu(String menuId) {
        try {
            // 清除所有菜单项的激活状态
            clearActiveMenuItems();
            
            // 查找并设置激活的菜单项
            VBox sidebar = (VBox) contentArea.getScene().lookup(".sidebar");
            if (sidebar != null) {
                ScrollPane scrollPane = (ScrollPane) sidebar.lookup(".sidebar-scroll");
                if (scrollPane != null) {
                    VBox menuContainer = (VBox) scrollPane.getContent();
                    if (menuContainer != null) {
                        setActiveMenuInContainer(menuContainer, menuId);
                    }
                }
            }
        } catch (Exception e) {
            logger.error("设置激活菜单失败", e);
        }
    }
    
    /**
     * 清除所有菜单项的激活状态
     */
    private void clearActiveMenuItems() {
        try {
            VBox sidebar = (VBox) contentArea.getScene().lookup(".sidebar");
            if (sidebar != null) {
                ScrollPane scrollPane = (ScrollPane) sidebar.lookup(".sidebar-scroll");
                if (scrollPane != null) {
                    VBox menuContainer = (VBox) scrollPane.getContent();
                    if (menuContainer != null) {
                        clearActiveMenuInContainer(menuContainer);
                    }
                }
            }
        } catch (Exception e) {
            logger.error("清除激活菜单状态失败", e);
        }
    }
    
    /**
     * 在容器中清除激活状态
     */
    private void clearActiveMenuInContainer(VBox container) {
        for (Node node : container.getChildren()) {
            if (node instanceof Accordion) {
                Accordion accordion = (Accordion) node;
                for (TitledPane pane : accordion.getPanes()) {
                    clearActiveMenuInPane(pane);
                }
            }
        }
    }
    
    /**
     * 在面板中清除激活状态
     */
    private void clearActiveMenuInPane(TitledPane pane) {
        if (pane.getContent() instanceof VBox) {
            VBox content = (VBox) pane.getContent();
            clearActiveMenuInVBox(content);
        }
    }
    
    /**
     * 在VBox中清除激活状态
     */
    private void clearActiveMenuInVBox(VBox vbox) {
        for (Node node : vbox.getChildren()) {
            if (node instanceof Button) {
                Button button = (Button) node;
                button.getStyleClass().remove("active");
            } else if (node instanceof VBox) {
                clearActiveMenuInVBox((VBox) node);
            }
        }
    }
    
    /**
     * 在容器中设置激活菜单
     */
    private void setActiveMenuInContainer(VBox container, String menuId) {
        for (Node node : container.getChildren()) {
            if (node instanceof Accordion) {
                Accordion accordion = (Accordion) node;
                for (TitledPane pane : accordion.getPanes()) {
                    if (setActiveMenuInPane(pane, menuId)) {
                        return; // 找到并设置了激活菜单，退出
                    }
                }
            }
        }
    }
    
    /**
     * 在面板中设置激活菜单
     */
    private boolean setActiveMenuInPane(TitledPane pane, String menuId) {
        if (pane.getContent() instanceof VBox) {
            VBox content = (VBox) pane.getContent();
            return setActiveMenuInVBox(content, menuId);
        }
        return false;
    }
    
    /**
     * 在VBox中设置激活菜单
     */
    private boolean setActiveMenuInVBox(VBox vbox, String menuId) {
        for (Node node : vbox.getChildren()) {
            if (node instanceof Button) {
                Button button = (Button) node;
                // 这里可以根据菜单ID或其他标识来判断是否应该激活
                // 暂时使用简单的文本匹配
                if (button.getText() != null && button.getText().contains(menuId)) {
                    button.getStyleClass().add("active");
                    return true;
                }
            } else if (node instanceof VBox) {
                if (setActiveMenuInVBox((VBox) node, menuId)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 更新面包屑导航
     */
    private void updateBreadcrumb(String category, String current) {
        if (currentPageLabel != null) {
            currentPageLabel.setText(current);
        }
        // 在实际项目中，您可能需要更新完整的面包屑路径
    }

    // ==================== 窗口控制方法 ====================

    /**
     * 最小化窗口
     */
    @FXML
    private void handleMinimize() {
        SceneManager.minimizeWindow();
    }

    /**
     * 最大化/还原窗口
     */
    @FXML
    private void handleMaximize() {
        isMaximized = !isMaximized;
        SceneManager.toggleMaximizeWindow();
        
        // 窗口最大化后优化布局
        Platform.runLater(() -> {
            optimizeLayoutForMaximize();
        });
    }
    
    /**
     * 窗口最大化后优化布局
     */
    private void optimizeLayoutForMaximize() {
        try {
            if (mainSplitPane == null) {
                mainSplitPane = (SplitPane) contentArea.getScene().lookup(".main-split-pane");
            }
            
            if (mainSplitPane != null && isMaximized) {
                // 最大化时调整分割面板的分割比例
                double currentWidth = mainSplitPane.getWidth();
                if (currentWidth > 1600) {
                    // 大屏幕时适当增加侧边栏宽度比例
                    mainSplitPane.setDividerPositions(0.2);
                } else if (currentWidth > 1200) {
                    // 中等屏幕时保持默认比例
                    mainSplitPane.setDividerPositions(0.18);
                } else {
                    // 小屏幕时减少侧边栏宽度比例
                    mainSplitPane.setDividerPositions(0.15);
                }
                
                logger.info("窗口最大化，已优化布局，当前宽度: {}", currentWidth);
            }
        } catch (Exception e) {
            logger.error("优化最大化布局失败", e);
        }
    }

    /**
     * 关闭窗口
     */
    @FXML
    private void handleClose() {
        SceneManager.closeWindow();
    }

    // ==================== 操作按钮方法 ====================

    /**
     * 显示通知中心
     */
    @FXML
    private void showNotifications() {
        showAlert("通知", "显示通知中心");
    }

    /**
     * 切换主题
     */
    @FXML
    private void toggleTheme() {
        showAlert("主题", "切换主题");
    }

    /**
     * 刷新数据
     */
    @FXML
    private void refreshData() {
        showAlert("操作", "刷新数据");
    }

    /**
     * 生成报告
     */
    @FXML
    private void generateReport() {
        showAlert("操作", "生成报告");
    }

    /**
     * 快速操作
     */
    @FXML
    private void quickAction() {
        showAlert("操作", "快速操作");
    }

    /**
     * 查看全部活动
     */
    @FXML
    private void viewAllActivities() {
        showAlert("操作", "查看全部活动");
    }

    /**
     * 刷新缓存
     */
    @FXML
    private void refreshCache() {
        showAlert("操作", "缓存刷新成功");
    }

    /**
     * 导出数据
     */
    @FXML
    private void exportData() {
        showAlert("操作", "数据导出开始");
    }

    /**
     * 显示帮助
     */
    @FXML
    private void showHelp() {
        showAlert("帮助", "打开帮助文档");
    }

    /**
     * 导出报表
     */
    @FXML
    private void exportReport() {
        showAlert("操作", "报表导出开始");
    }

    /**
     * 备份数据
     */
    @FXML
    private void backupData() {
        showAlert("操作", "数据备份开始");
    }

    /**
     * 保存用户
     */
    private void saveUser() {
        showAlert("操作", "用户保存成功");
    }

    /**
     * 刷新菜单
     */
    @FXML
    private void refreshMenu() {
        try {
            menuService.refreshMenu();
            buildDynamicMenu();
            showAlert("操作", "菜单刷新成功");
        } catch (Exception e) {
            logger.error("刷新菜单失败", e);
            showError("菜单刷新失败: " + e.getMessage());
        }
    }

    // ==================== 退出登录方法 ====================

    /**
     * 退出登录
     */
    @FXML
    private void handleLogout() {
        Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
        alert.setTitle("确认退出");
        alert.setHeaderText("确定要退出登录吗？");
        alert.setContentText("您将返回到登录页面");

        // 设置对话框样式
        DialogPane dialogPane = alert.getDialogPane();
        dialogPane.getStylesheets().add(getClass().getResource("/css/main.css").toExternalForm());
        dialogPane.getStyleClass().add("confirmation-dialog");

        alert.showAndWait().ifPresent(response -> {
            if (response == ButtonType.OK) {
                performLogout();
            }
        });
    }

    /**
     * 执行退出登录操作
     */
    private void performLogout() {
        try {
            // 这里可以添加清理操作，比如：
            // 1. 清除用户会话数据
            // 2. 停止后台任务
            // 3. 保存用户偏好设置等

            logger.info("用户退出登录，清理会话数据...");

            // 停止可能正在运行的后台任务
            stopBackgroundTasks();

            // 清除用户数据
            clearUserData();

            // 切换到登录页面
            SceneManager.returnToLogin();

        } catch (Exception e) {
            logger.error("退出登录失败", e);
            // 即使出现异常也强制跳转到登录页
            SceneManager.returnToLogin();
        }
    }

    /**
     * 停止后台任务
     */
    private void stopBackgroundTasks() {
        // 停止可能正在运行的任务，比如：
        // - 数据轮询任务
        // - 定时器任务
        // - WebSocket连接等
        logger.info("停止后台任务...");
    }

    /**
     * 清除用户数据
     */
    private void clearUserData() {
        // 清除用户相关的临时数据
        // 例如：清除缓存、重置状态等
        logger.info("清除用户数据...");
    }

    // ==================== 状态栏和搜索功能 ====================

    /**
     * 设置状态栏信息
     */
    private void setupStatusBar() {
        if (currentUserLabel != null) {
            currentUserLabel.setText("管理员");
        }
        if (lastLoginLabel != null) {
            lastLoginLabel.setText("最后登录: " + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        }
        if (systemStatusLabel != null) {
            systemStatusLabel.setText("系统运行正常");
        }
        if (connectionStatusLabel != null) {
            connectionStatusLabel.setText("网络连接正常");
        }
    }

    /**
     * 设置全局搜索功能
     */
    private void setupGlobalSearch() {
        if (globalSearchField != null) {
            globalSearchField.setOnAction(event -> performGlobalSearch());
        }
    }

    /**
     * 开始时间更新
     */
    private void startTimeUpdate() {
        if (currentTimeLabel != null) {
            timeUpdateTimeline = new Timeline(new KeyFrame(Duration.seconds(1), event -> {
                String currentTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
                currentTimeLabel.setText(currentTime);
            }));
            timeUpdateTimeline.setCycleCount(Timeline.INDEFINITE);
            timeUpdateTimeline.play();
        }
    }

    /**
     * 执行全局搜索
     */
    @FXML
    private void performGlobalSearch() {
        if (globalSearchField != null) {
            String searchText = globalSearchField.getText().trim();
            if (!searchText.isEmpty()) {
                logger.info("执行全局搜索: {}", searchText);
                showAlert("搜索", "搜索功能: " + searchText + " (功能开发中)");
            }
        }
    }

    /**
     * 切换全屏模式
     */
    @FXML
    private void toggleFullscreen() {
        isMaximized = !isMaximized;
        SceneManager.toggleMaximizeWindow();
        logger.info("切换全屏模式: {}", isMaximized ? "全屏" : "窗口");
    }

    /**
     * 导航到界面设置
     */
    @FXML
    private void navigateToInterfaceSettings() {
        showPlaceholderPage("界面设置", "interfaceSettings");
        updateBreadcrumb("系统设置", "界面设置");
        setActiveMenu("interfaceSettings");
    }

    /**
     * 显示系统状态
     */
    @FXML
    private void showSystemStatus() {
        showAlert("系统状态", "系统运行正常\n内存使用: 65%\nCPU使用: 23%\n磁盘空间: 78%");
    }
    
    /**
     * 设置窗口大小变化监听器
     */
    private void setupWindowSizeListener() {
        try {
            if (contentArea != null && contentArea.getScene() != null) {
                contentArea.getScene().widthProperty().addListener((obs, oldVal, newVal) -> {
                    Platform.runLater(() -> adjustLayoutForSize(newVal.doubleValue(), contentArea.getScene().getHeight()));
                });
                
                contentArea.getScene().heightProperty().addListener((obs, oldVal, newVal) -> {
                    Platform.runLater(() -> adjustLayoutForSize(contentArea.getScene().getWidth(), newVal.doubleValue()));
                });
                
                logger.info("窗口大小变化监听器设置完成");
            }
        } catch (Exception e) {
            logger.error("设置窗口大小变化监听器失败", e);
        }
    }
    
    /**
     * 根据窗口大小调整布局
     */
    private void adjustLayoutForSize(double width, double height) {
        try {
            if (mainSplitPane == null) {
                mainSplitPane = (SplitPane) contentArea.getScene().lookup(".main-split-pane");
            }
            
            if (mainSplitPane != null) {
                // 根据窗口宽度调整分割比例
                if (width > 1920) {
                    // 超大屏幕
                    mainSplitPane.setDividerPositions(0.22);
                } else if (width > 1600) {
                    // 大屏幕
                    mainSplitPane.setDividerPositions(0.20);
                } else if (width > 1200) {
                    // 中等屏幕
                    mainSplitPane.setDividerPositions(0.18);
                } else {
                    // 小屏幕
                    mainSplitPane.setDividerPositions(0.15);
                }
                
                logger.debug("根据窗口大小调整布局: {}x{}, 分割比例: {}", width, height, mainSplitPane.getDividerPositions()[0]);
            }
        } catch (Exception e) {
            logger.error("调整布局失败", e);
        }
    }

    // ==================== 工具方法 ====================

    /**
     * 显示信息提示
     */
    private void showAlert(String title, String message) {
        // 在实际项目中，这里可以替换为更优雅的通知方式
        logger.info("{}: {}", title, message);

        // 示例：显示简单的信息对话框
        Alert alert = new Alert(Alert.AlertType.INFORMATION);
        alert.setTitle(title);
        alert.setHeaderText(null);
        alert.setContentText(message);
        alert.showAndWait();
    }

    /**
     * 显示错误提示
     */
    private void showError(String message) {
        Alert alert = new Alert(Alert.AlertType.ERROR);
        alert.setTitle("错误");
        alert.setHeaderText(null);
        alert.setContentText(message);
        alert.showAndWait();
    }

    /**
     * 获取内容区域
     */
    public StackPane getContentArea() {
        return contentArea;
    }

    /**
     * 获取当前页面
     */
    public String getCurrentPage() {
        return currentPage;
    }
}